package io;

import java.io.*;
import java.nio.channels.FileChannel;

/**
 * @Description: null
 * @Project: testDemo
 * @Author: hjibo
 * @CreateDate: 2019/2/23 09:34
 * @ModificationHistory: （who whatTime doWhat）
 */
public class Maaa {

    public static void main(String[] args) {

        try {
            long start = System.currentTimeMillis();
//            ioOption4();
            ioOption();
            long end = System.currentTimeMillis();
            System.out.println("耗时(毫秒)："+(end-start));

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

// 测试文件大小：8832KB
public static void ioOption() throws IOException {

    // 文件输入流通道
    FileChannel inputChannel = new FileInputStream(new File("D:/demo.txt")).getChannel();
    // 文件输出流通道
    FileChannel outputChannel = new FileOutputStream(new File("D:/copy.txt")).getChannel();

    // 文件转移起始位置，默认0
    long position  = 0;
    // 文件长度
    long size  = inputChannel.size();
    // 数据转移
    // count 转移的字节数
    long count = inputChannel.transferTo(position, size, outputChannel);
    // 循环方式，转移数据
    // 比如：
    // 文件长度为220，但是一次只能转移100；position = 0，size = 220
    // 100 < 220,
    // 第二次从100开始，转移长度为120；position = 100，size = 120
    // 100 < 120,
    // 第三次从200开始，转移长度为20；position = 200，size = 20
    // 20 = 20
    // 退出循环，转移完毕
    while(count < size){
        position += count;
        size -= count;
        count = inputChannel.transferTo(position, size, outputChannel);
    }

    inputChannel.close();
    outputChannel.close();
}

public static Student ioOption13(byte[] bytes) throws IOException, ClassNotFoundException {

    // 字节数组输入流
    ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
    // 缓冲字节输出流
    ObjectInputStream ois = new ObjectInputStream(bais);

    return (Student) ois.readObject();
}

// Student 类必须实现 Serializable 接口
public static byte[] ioOption12(Student student) throws IOException {

    // 字节数组输出流
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    // 对象字节输出流
    ObjectOutputStream oos = new ObjectOutputStream(baos);
    // 将对象写进 baos
    oos.writeObject(student);

    baos.close();
    oos.close();
    return baos.toByteArray();
}

// 测试文件大小：2087KB
public static void ioOption11(byte[] bytes) throws IOException {

    // 字节数组输入流
    ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
    // 缓冲字节输出流
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("D:/copy.txt")));

    byte[] buffer = new byte[1024];
    int len;
    while((len = bais.read(buffer))!=-1){
        bos.write(buffer,0,len);
    }

    bais.close();
    bos.close();
}

// 测试文件大小：2087KB
public static byte[] ioOption10() throws IOException {

    // 缓冲字节输入流
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("D:/demo.txt")));
    // 字节数组输出流
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    byte[] bytes = new byte[1024];
    int len;
    while((len = bis.read(bytes))!=-1){
        baos.write(bytes,0,len);
    }

    bis.close();
    baos.close();
    return baos.toByteArray();
}

// 测试文件大小：2087KB
public static void ioOption9() throws IOException {

    // 获取文件 字符输入流，如果文件不存在抛出异常
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:/demo.txt")),"GBK"));
    // 获取文件 字符输出流，如果文件不存在自动创建文件
    BufferedWriter bw  = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("D:/copy.txt")),"GBK"));

    // 字符数组
    char[] chars = new char[1024];
    int cha;
    // 一次读取一个字符，读到换行符会自动换行
    // cha 表示读取到的字符，如果没有数据则返回 -1
    while ((cha = br.read(chars))!= -1){
        bw.write(chars,0,cha);
    }

    br.close();
    bw.flush();
    bw.close();
}

// 测试文件大小：2087KB
public static void ioOption8() throws IOException {

    // 获取文件 字符输入流，如果文件不存在抛出异常
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:/demo.txt")),"GBK"));
    // 获取文件 字符输出流，如果文件不存在自动创建文件
    BufferedWriter bw  = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("D:/copy.txt")),"GBK"));

    int cha;
    // 一次读取一个字符，读到换行符会自动换行
    // cha 表示读取到的字符，如果没有数据则返回 -1
    while ((cha = br.read())!= -1){
        bw.write(cha);
    }

    br.close();
    bw.flush();
    bw.close();
}

// 测试文件大小：2087KB
public static void ioOption7() throws IOException {

    // 获取文件 字符输入流，如果文件不存在抛出异常
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:/demo.txt")),"GBK"));
    // 获取文件 字符输出流，如果文件不存在自动创建文件
    PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream(new File("D:/copy.txt")),"GBK"));

    String content;
    // 一次读取一行
    // content 表示读取到的内容，如果没有数据则返回 null
    while ((content = br.readLine())!= null){
        pw.println(content);
    }

    br.close();
    pw.flush();
    pw.close();
}

// 测试文件大小：2087KB
public static void ioOption6() throws IOException {

    // 获取文件 字符输入流，如果文件不存在抛出异常
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:/demo.txt")),"GBK"));
    // 获取文件 字符输出流，如果文件不存在自动创建文件
    BufferedWriter bw  = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("D:/copy.txt")),"GBK"));

    String content;
    // 一次读取一行
    // content 表示读取到的内容，如果没有数据则返回 null
    while ((content = br.readLine())!= null){
        bw.write(content);
        bw.newLine();
    }

    br.close();
    bw.flush();
    bw.close();
}

// 测试文件大小：2087KB
public static void ioOption5() throws IOException {

    // 获取文件 字节输入流，如果文件不存在抛出异常
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("D:/demo.txt")));
    // 获取文件 字节输出流，如果文件不存在自动创建文件
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("D:/copy.txt")));

    int len = 0;
    // 一次读取一个字节
    // len 表示读取到的字节数，如果没有数据则返回 -1
    while ((len = bis.read())!= -1){
        bos.write(len);
    }

    bis.close();
    bos.close();
}

// 测试文件大小：2087KB
public static void ioOption4() throws IOException {

    // 获取文件 字节输入流，如果文件不存在抛出异常
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("D:/demo.txt")));
    // 获取文件 字节输出流，如果文件不存在自动创建文件
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("D:/copy.txt")));
    // 字节数组
    byte[] bytes = new byte[1024];

    int len = 0;
    // 一次读取一个 bytes 大小的数据
    // len 表示读取到的字节数，如果没有数据则返回 -1
    while ((len = bis.read(bytes))!= -1){
        bos.write(bytes,0,len);
    }

    bis.close();
    bos.close();
}

// 测试文件大小：2087KB
public static void ioOption3() throws IOException {

    // 获取文件 字节输入流，如果文件不存在抛出异常
    FileInputStream fis = new FileInputStream(new File("D:/demo.txt"));
    // 获取文件 字节输出流，如果文件不存在自动创建文件
    FileOutputStream fos = new FileOutputStream(new File("D:/copy.txt"));
    // 字节数组
    byte[] bytes = new byte[1024];

    int len = 0;
    // 一次读取一个 bytes 大小的数据
    // len 表示读取到的字节数，如果没有数据则返回 -1
    while ((len = fis.read(bytes))!= -1){
        fos.write(bytes,0,len);
    }

    fis.close();
    fos.close();
}

// 测试文件大小：2087KB
public static void ioOption2() throws IOException {

    // 获取文件 字节输入流，如果文件不存在抛出异常
    FileInputStream fis = new FileInputStream(new File("D:/demo.txt"));
    // 获取文件 字节输出流，如果文件不存在自动创建文件
    FileOutputStream fos = new FileOutputStream(new File("D:/copy.txt"));
    // 字节数组
    byte[] bytes = new byte[fis.available()];

    int len = 0;
    // 一次读取一个 bytes 大小的数据
    // len 表示读取到的字节数，如果没有数据则返回 -1
    while ((len = fis.read(bytes))!= -1){
        fos.write(bytes,0,len);
    }

    fis.close();
    fos.close();
}

// 测试文件大小：2087KB
public static void ioOption1() throws IOException {

    // 获取文件 字节输入流，如果文件不存在抛出异常
    FileInputStream fis = new FileInputStream(new File("D:/demo.txt"));
    // 获取文件 字节输出流，如果文件不存在自动创建文件
    FileOutputStream fos = new FileOutputStream(new File("D:/copy.txt"));

    int len = 0;
    // 一次读取一个字节
    // len 表示读取到的字节数，如果没有数据则返回 -1
    while ((len = fis.read())!= -1){
        fos.write(len);
    }

    fis.close();
    fos.close();
}
}
